import matplotlib.pyplot as plt
import numpy as np
import pandas as pd 
import skimage.measure

import random
import copy
import math
import cv2
import os
import sys

import argparse
import datetime
import json
import time
from pathlib import Path

import torch

import models_mae
import util.misc as misc
from engine_pretrain import train_one_epoch
from main_ViT import main, get_args_parser, run_one_image, DATASET_PATH, SemanticMapDataset
import timm.optim.optim_factory as optim_factory
from util.misc import NativeScalerWithGradNormCount as NativeScaler

from scipy.stats import wasserstein_distance

/tmp/ipykernel_2029703/3885390031.py:3: DeprecationWarning: 
Pyarrow will become a required dependency of pandas in the next major release of pandas (pandas 3.0),
(to allow more performant data types, such as the Arrow string type, and better interoperability with other libraries)
but was not found to be installed on your system.
If this would cause problems for you,
please provide us feedback at https://github.com/pandas-dev/pandas/issues/54466
        
  import pandas as pd
2024-02-27 10:09:07.779749: I tensorflow/core/util/port.cc:113] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.
2024-02-27 10:09:07.811959: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered
2024-02-27 10:09:07.811986: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered
2024-02-27 10:09:07.812958: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered
2024-02-27 10:09:07.818334: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.
To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.
2024-02-27 10:09:08.436717: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT
/usr/lib/python3/dist-packages/scipy/__init__.py:146: UserWarning: A NumPy version >=1.17.3 and <1.25.0 is required for this version of SciPy (detected version 1.26.3
  warnings.warn(f"A NumPy version >={np_minversion} and <{np_maxversion}"

div = 64
step = int(32/4)
red = 1

mask_ratio = 0
test_name = '13labels_testMAE2'
n_crops = 500

box = 4
kernel = np.ones((box,box),np.float32)/(box**2)

map_list_t = ['master_big','master_big_closed','master_big_semiclosed']
map_root_name = 'master_big'

sem_dict = ['bicycle_road', 'building', 'entrance', 'grass', 'obstacle', 'parking', 'pedestrian_road', 'tree', 'vehicle_road', 'sitting_area', 'stairs', 'intersection_zone', 'shaded_area']
chans = len(sem_dict)

lut_in = [0, 10, 30, 50, 70, 110, 150, 255]
lut_out = [0, 120, 200, 225, 240, 248, 250, 255]
lut_in = [0, 10, 70, 150, 255]
lut_out = [0, 130, 210, 245, 255]
# plt.plot(lut_in, lut_out)
lut_8u = np.interp(np.arange(0, 256), lut_in, lut_out).astype(np.uint8)

# args = get_args_parser()
# args = args.parse_args()

# args.resume = '/home/placido.falqueto/IRI_Barcelona/mae/output_dir/test3-checkpoint-100.pth'

# device = torch.device(args.device)

# # define the model
# model = models_mae.__dict__[args.model](norm_pix_loss=args.norm_pix_loss)

# model.to(device)

# model_without_ddp = model

# eff_batch_size = args.batch_size * args.accum_iter * misc.get_world_size()

# if args.lr is None:  # only base_lr is specified
#     args.lr = args.blr * eff_batch_size / 256

# # following timm: set wd as 0 for bias and norm layers
# param_groups = optim_factory.add_weight_decay(model_without_ddp, args.weight_decay)
# optimizer = torch.optim.AdamW(param_groups, lr=args.lr, betas=(0.9, 0.95))
# loss_scaler = NativeScaler()

# misc.load_model(args=args, model_without_ddp=model_without_ddp, optimizer=optimizer, loss_scaler=loss_scaler)

# red1 = 8

# for map_name in map_list_t:
#   print(map_name)

#   lines = 0
#   try:
#     with open('/home/placido.falqueto/IRI_Barcelona/maps/13semantics/'+map_root_name+'/'+map_name+'-reduced.csv') as f:
#       print('Reduced map found')
#       lines = f.readlines()
      
#   except FileNotFoundError:
#     with open('/home/placido.falqueto/IRI_Barcelona/maps/13semantics/'+map_root_name+'/'+map_name+'.csv') as f:
#       print('Using original map')
#       lines = f.readlines()

#   h = len(lines)
#   w = len(lines[0].split(','))

#   # Converts data to a list of integers
#   map = []
#   for line in lines:
#     map.extend([int(c) for c in line.split(',')])

#   for lab_class in sem_dict:
#     lines = 0
#     try:
#       with open('/home/placido.falqueto/IRI_Barcelona/maps/13semantics/'+map_name+'/'+map_name+'_sem_'+lab_class+'-reduced.csv') as f:
#         lines = f.readlines()

#       hh = len(lines)
#       ww = len(lines[0].split(','))

#       if hh != h or ww != w:
#         print(f'h: {h}\tw: {w}')
#         print(f'h: {hh}\tw: {ww}')
#         raise SystemExit("ERROR: Different sizes!!")

#       # Converts data to a list of integers
#       for line in lines:
#         map.extend([int(c) for c in line.split(',')])
    
#     except FileNotFoundError:
#       try:
#         with open('/home/placido.falqueto/IRI_Barcelona/maps/13semantics/'+map_root_name+'/'+map_name+'_sem_'+lab_class+'.csv') as f:
#           lines = f.readlines()

#         hh = len(lines)
#         ww = len(lines[0].split(','))

#         if hh != h or ww != w:
#           print(f'h: {h}\tw: {w}')
#           print(f'h: {hh}\tw: {ww}')
#           raise SystemExit("ERROR: Different sizes!!")

#         # Converts data to a list of integers
#         for line in lines:
#           map.extend([int(c) for c in line.split(',')])

#       except FileNotFoundError:
#         for i in range(h):
#           for j in range(w):
#             map.extend([255])

#   map = np.reshape(map,[chans,h,w])
#   map = np.moveaxis(map, 0, -1)
#   map = map/255

#   map_aux = map
#   map = np.zeros((int(math.ceil(h/red1)),int(math.ceil(w/red1)),chans))

#   for idx in range(chans):
#     map[:,:,idx] = skimage.measure.block_reduce(map_aux[:,:,idx], (red1,red1), np.max)

#   # print(map.shape)
#   h, w, _ = map.shape

#   lines = 0
#   with open('/home/placido.falqueto/IRI_Barcelona/maps/13semantics/'+map_root_name+'/humandensity-'+map_root_name+'-new.csv') as f:
#     lines = f.readlines()

#   hd = len(lines)
#   wd = len(lines[0].split(','))

#   # Converts data to a list of integers
#   data = []
#   for line in lines:
#     data.extend([int(c) for c in line.split(',')])

#   data = np.reshape(data,[hd,wd])
  
#   sigma = 10.0
#   # data = skimage.filters.gaussian(data, sigma=(sigma, sigma), channel_axis=-1)
#   data = skimage.measure.block_reduce(data, (red1,red1), np.max)
#   # data = np.subtract(data, np.full((h, w), np.min(data)))/(np.max(data)-np.min(data))
#   data = data*(map[:,:,0]>0)
  
#   lim_val = 0.15
#   sigma = 0.5
#   data_show = np.clip(data,0,np.max(data)*lim_val)/(np.max(data)*lim_val)
#   data_show = cv2.LUT((data_show*255).astype(np.uint8), lut_8u).astype(np.float32)/255
#   data_show = skimage.filters.gaussian(data_show, sigma=(sigma, sigma), channel_axis=-1)
#   data = data_show/np.sum(data_show)

#   # -----------------------------------------------------------------------------------
#   # Random sample 32x32 windows in map
#   n_crops = 100
#   inserted = 0
#   crops = np.zeros((n_crops,2),dtype=int)
#   selections = np.zeros((h,w))
#   for i in range(n_crops):
#     background = np.zeros((h,w))
#     flag = True
#     while flag:
#       aux_x = int(random.random()*(w-div+1))
#       aux_y = int(random.random()*(h-div+1))
#       flag = False
#       # print(f'INSERTED: {inserted}  ->  x: {aux_x} and y: {aux_y}')
#       # for z in range(inserted):
#       #   if abs(aux_x-crops[z,0])<int(div/10) and abs(aux_y-crops[z,1])<int(div/10):
#       #     # print('too close')
#       #     flag = True
#     crops[i,0] = aux_x
#     crops[i,1] = aux_y
#     selections = selections+cv2.rectangle(background,(crops[i,0],crops[i,1]),(crops[i,0]+div-1,crops[i,1]+div-1),(1,1,1),-1)
#     inserted = inserted + 1
#   selections = 1/selections

#   # -----------------------------------------------------------------------------------
#   # creating subplot and figure
#   ax = plt.subplot(111)
#   data_pred = np.zeros((int(math.ceil(h)),int(math.ceil(w))))
#   kls = []
#   for i in range(n_crops):
#     submap = map[crops[i,1]:crops[i,1]+div, crops[i,0]:crops[i,0]+div,:]
#     data_aux = data[crops[i,1]:crops[i,1]+div, crops[i,0]:crops[i,0]+div]
#     submap = torch.tensor(np.expand_dims(submap,axis=0), dtype=torch.float32).to(device)
#     _, subdata, _ = model(submap)
#     subdata = torch.einsum('nchw->nhwc', subdata).detach().cpu()
#     subdata = subdata.squeeze(dim=0).squeeze(dim=2).numpy()
#     data_pred[crops[i,1]:crops[i,1]+div, crops[i,0]:crops[i,0]+div] += subdata*selections[crops[i,1]:crops[i,1]+div, crops[i,0]:crops[i,0]+div]
    
#   data = torch.Tensor(data)
#   data_pred = torch.Tensor(data_pred)
#   data = data/data.max()
#   data_pred = data_pred/data_pred.max()
  
#   data_pred = data_pred/np.max(data_pred.detach().cpu().numpy())
#   plt.imshow(np.multiply(np.stack((map[:,:,0],map[:,:,0],map[:,:,0]),axis=2), np.stack((np.full(data_pred.shape,1),1-data_pred,1-data_pred),axis=2)), vmin=0, vmax=1)
#   # plt.imshow(np.multiply(np.stack((map[:,:,0],map[:,:,0],map[:,:,0]),axis=2), np.stack((np.full(data_pred.shape,1),1-data_pred,1-data_pred),axis=2)), vmin=0, vmax=1)
#   ax.get_xaxis().set_visible(False)
#   ax.get_yaxis().set_visible(False)
#   plt.show()

def show_image(features, data, title=''):
    # features is [H, W, C]
    # plt.imshow(torch.clip((features * imagenet_std + imagenet_mean) * 255, 0, 255).int())
    data = data / data.max()
    test11 = np.stack((features[:,:,0],features[:,:,0],features[:,:,0]),axis=2)
    test11 = np.multiply(test11,np.stack((np.full(data.shape,1),1-data,1-data),axis=2))
    for i in range(10):
        alp = 0.5
        test11 = np.multiply(test11,np.stack((features[:,:,i+1],features[:,:,i+1],features[:,:,i+1]),axis=2)*alp+(1-alp))
    plt.imshow(test11)
    plt.title(title, fontsize=23)
    plt.axis('off')
    return

def run_one_image(x, target, model):
    # run MAE
    x = x.to('cuda')
    target = target.to('cuda')
    _, y, mask = model(x, mask_ratio=mask_ratio)
    x = x.detach().cpu()
    target = target.detach().cpu()
    
    y = y.squeeze(3).detach().cpu()

    is_mae = 0
    # if mask is not None:
    #     # visualize the mask
    #     mask = mask.detach()
    #     mask = mask.unsqueeze(-1).repeat(1, 1, model.patch_embed.patch_size[0]**2 *1)  # (N, H*W, p*p*3)
    #     mask = model.unpatchify(mask)  # 1 is removing, 0 is keeping
    #     mask = torch.einsum('nchw->nhwc', mask).detach().cpu()
    #     mask = mask.squeeze(-1)

    #     plt.figure()
    #     plt.imshow(mask[0])
    #     plt.show()

    #     # masked image
    #     im_masked = target * (1 - mask) + mask*target.max()

    #     is_mae = 1

    # # MAE reconstruction pasted with visible patches
    # im_paste = x * (1 - mask) + y * mask

    # make the plt figure larger
    plt.rcParams['figure.figsize'] = [24, 12] # W: 24, H: 12

    plt.subplot(1, 2+is_mae, 1)
    show_image(x[0], target[0], "original")

    if is_mae:
        plt.subplot(1, 2+is_mae, 2)
        show_image(x[0], im_masked[0], "masked")

    plt.subplot(1, 2+is_mae, 2+is_mae)
    show_image(x[0], y[0], "prediction")

    # plt.subplot(1, 4, 3)
    # plt.imshow(target[0])
    # plt.title('target', fontsize=23)
    # plt.axis('off')

    # plt.subplot(1, 4, 4)
    # plt.imshow(y[0])
    # plt.title('y', fontsize=23)
    # plt.axis('off')

    plt.show()

kl1 = []
kli1 = []
was1 = []
mse1 = []

# get file list from /data/placido filtering only files that start with test_name
map_list = [f for f in os.listdir('/data/placido') if f.startswith(test_name)]
# remove the element in map_list that contains 'gates0'
map_list = [f for f in map_list if 'gates0' not in f]

print(map_list)

for map_count, map_path in enumerate(map_list):
  # map_path is test11-checkpoint-70-stanford_deathCircle0.pth, we need to isolate the map name (after stanford_ and before .pth)
  map_name = map_path.split('-')[3].split('.')[0]
  print(map_name)

  args = get_args_parser()
  args = args.parse_args()

  args.resume = '/data/placido/'+map_path

  device = torch.device(args.device)

  # define the model
  model = models_mae.__dict__[args.model](norm_pix_loss=args.norm_pix_loss)

  model.to(device)

  model_without_ddp = model

  eff_batch_size = args.batch_size * args.accum_iter * misc.get_world_size()

  if args.lr is None:  # only base_lr is specified
      args.lr = args.blr * eff_batch_size / 256

  # following timm: set wd as 0 for bias and norm layers
  param_groups = optim_factory.add_weight_decay(model_without_ddp, args.weight_decay)
  optimizer = torch.optim.AdamW(param_groups, lr=args.lr, betas=(0.9, 0.95))
  loss_scaler = NativeScaler()

  misc.load_model(args=args, model_without_ddp=model_without_ddp, optimizer=optimizer, loss_scaler=loss_scaler)


# -----------------------------------------------------------------------------------
  lines = 0
  with open('../maps/13semantics/'+map_name+'/humandensity-'+map_name+'-new.csv') as f:
    lines = f.readlines()

  hd = len(lines)
  wd = len(lines[0].split(','))

  # Converts data to a list of integers
  data = []
  for line in lines:
    data.extend([float(c) for c in line.split(',')])

  data = np.reshape(data,[hd,wd])
  data = skimage.measure.block_reduce(data, (red,red), np.max)

  # print(data.shape)
  hd, wd = data.shape
  
  data_show = data
  data_show = cv2.filter2D(data_show,-1,kernel)
  data_show = cv2.filter2D(data_show,-1,kernel)
  data = data_show/np.sum(data_show)
  data_show = data_show/np.max(data_show)

  # -----------------------------------------------------------------------------------

  png_path = '../maps/13semantics/'+map_name+'/'+map_name+'_colors.png'
  labelmap_path = '../maps/13semantics/labelmap.txt'

  # Read the labelmap file
  with open(labelmap_path, 'r') as f:
      labelmap = f.readlines()
  labelmap.pop(0)
  labelmap.pop(0)

  # Load the PNG image
  image = cv2.imread(png_path)
  image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

  image = cv2.resize(image, (wd,hd), interpolation = cv2.INTER_LINEAR)
  map = np.zeros((hd,wd,chans))

  # fig = plt.figure(figsize=(5,5))
  # plt.imshow(image)
  # plt.axis('off')
  # plt.show()

  colors = []
  # Iterate over each label in the labelmap
  for i, label in enumerate(labelmap):
      label = label.strip().split(':')
      label_name = label[0]
      label_color = np.array(label[1].split(','), dtype=int)
      colors.append(label_color)
      # Create a mask for the pixels with the label color
      map[:,:,i] = 255-cv2.inRange(image, label_color-10, label_color+10)

  # check if map_name_shades.png exists and if so, add it to the map
  if os.path.isfile('/home/placido.falqueto/IRI_Barcelona/maps/13semantics/'+map_name+'/'+map_name+'_shades.png'):
    png_path = '/home/placido.falqueto/IRI_Barcelona/maps/13semantics/'+map_name+'/'+map_name+'_shades.png'
    # Load the PNG image
    image = cv2.imread(png_path)
    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    image = cv2.resize(image, (wd,hd), interpolation = cv2.INTER_LINEAR)
    map[:,:,-1] = 255-cv2.inRange(image, label_color-10, label_color+10)

  map = map/255

  # print(map.shape)
  h, w, _ = map.shape

  sem_map = np.zeros((h,w,3))
  for i in range(len(sem_dict)):
    sem = np.full((h,w,3),colors[i])
    sem_map = np.stack((1-map[:,:,i],1-map[:,:,i],1-map[:,:,i]), axis=2)*sem+sem_map

  fig = plt.figure(figsize=(5,5))
  plt.imshow(sem_map/255)
  plt.axis('off')
  plt.show()

  fig = plt.figure(figsize=(5,5))
  plt.imshow(data_show)
  plt.axis('off')
  plt.show()

  # -----------------------------------------------------------------------------------
  # Random sample 32x32 windows in map
  inserted = 0
  crops = np.zeros((n_crops,2),dtype=int)
  selections = np.zeros((h,w))
  for i in range(n_crops):
    background = np.zeros((h,w))
    flag = True
    while flag:
      aux_x = int(random.random()*(w-div+1))
      aux_y = int(random.random()*(h-div+1))
      flag = False
      # print(f'INSERTED: {inserted}  ->  x: {aux_x} and y: {aux_y}')
      # for z in range(inserted):
      #   if abs(aux_x-crops[z,0])<int(div/10) and abs(aux_y-crops[z,1])<int(div/10):
      #     # print('too close')
      #     flag = True
    crops[i,0] = aux_x
    crops[i,1] = aux_y
    selections = selections+cv2.rectangle(background,(crops[i,0],crops[i,1]),(crops[i,0]+div-1,crops[i,1]+div-1),(1,0,0),-1)
    inserted = inserted + 1
  selections = 1/selections

  # -----------------------------------------------------------------------------------
  # creating subplot and figure
  # ax = plt.subplot(111)
  data_pred = np.zeros((int(math.ceil(h)),int(math.ceil(w))))
  kls = []
  for i in range(n_crops):
    submap = map[crops[i,1]:crops[i,1]+div, crops[i,0]:crops[i,0]+div,:]
    data_aux = data[crops[i,1]:crops[i,1]+div, crops[i,0]:crops[i,0]+div]
    submap = torch.tensor(np.expand_dims(submap,axis=0), dtype=torch.float32).to(device)
    data_aux = torch.tensor(np.expand_dims(data_aux,axis=0), dtype=torch.float32).to(device)
    _, subdata, _ = model(submap, mask_ratio=mask_ratio)
    subdata = subdata.detach().cpu() #torch.einsum('nchw->nhwc', subdata).detach().cpu()
    subdata = subdata.squeeze(dim=0).squeeze(dim=2).numpy()
    data_pred[crops[i,1]:crops[i,1]+div, crops[i,0]:crops[i,0]+div] += subdata*selections[crops[i,1]:crops[i,1]+div, crops[i,0]:crops[i,0]+div]
    # Calculate the KL-divergence
    
  data = torch.Tensor(data)
  data_pred = torch.Tensor(data_pred)
  data = data/data.sum()
  data_pred = data_pred/data_pred.sum()
  data_pred[data_pred == 0] = 1e-12
  data_pred[data_pred == 1] = 1-1e-12
  data[data == 0] = 1e-12
  data[data == 1] = 1-1e-12

  kl = torch.nn.functional.kl_div(data_pred.unsqueeze(0).log(), data.unsqueeze(0), reduction='batchmean').item()
  kli = torch.nn.functional.kl_div(data.unsqueeze(0).log(), data_pred.unsqueeze(0), reduction='batchmean').item()
  h, w = data.shape
  data_aux = (data / data.max() * 255).detach().cpu().numpy().astype(int)
  pred_aux = (data_pred / data_pred.max() * 255).detach().cpu().numpy().astype(int)
  hist_a = [0.0] * 256
  for i in range(h):
    for j in range(w):
      hist_a[data_aux[i, j]] += 1
  hist_b = [0.0] * 256
  for i in range(h):
    for j in range(w):
      hist_b[pred_aux[i, j]] += 1
  was = wasserstein_distance(hist_a, hist_b)
  mse = ((data - data_pred)**2).mean()

  data = data/data.max()
  data_pred = data_pred/data_pred.max()
  plt.figure(figsize=(4,4))
  plt.imshow(np.multiply(np.stack((1-data,1-data,np.full(data.shape,1)),axis=2), np.stack((np.full(data_pred.shape,1),1-data_pred,1-data_pred),axis=2)))
  plt.axis('off')
  plt.show()
  
  data_pred = data_pred/np.max(data_pred.detach().cpu().numpy())
  plt.figure(figsize=(5,5))
  plt.imshow(data_pred)
  # plt.imshow(np.multiply(np.stack((map[:,:,0],map[:,:,0],map[:,:,0]),axis=2), np.stack((np.full(data_pred.shape,1),1-data_pred,1-data_pred),axis=2)), vmin=0, vmax=1)
  plt.axis('off')
  plt.show()

  print(f'KL-divergence: {kl}')
  print(f'Reverse KL-divergence: {kli}')
  print(f'EMD: {was:.2f}')
  print(f'MSE: {mse:.2e}')
  kl1 = np.append(kl1,kl)
  kli1 = np.append(kli1,kli)
  was1 = np.append(was1,was)
  mse1 = np.append(mse1,mse)
  # import sys
  # sys.exit(0)

print('-----------------------------')
print(f'Mean KL-divergence: {np.mean(kl1)}')
print(f'Std KL-divergence: {np.std(kl1)}')
print(f'Mean reverse KL-divergence: {np.mean(kli1)}')
print(f'Std reverse KL-divergence: {np.std(kli1)}')
print(f'Mean EMD: {np.mean(was1):.2f}')
print(f'Std EMD: {np.std(was1):.2f}')

# plot KL-div
plt.figure(figsize=(10,5))
plt.plot(kl1, label='KL-divergence')
plt.legend()
plt.show()

# plot all metrics normalized
plt.figure(figsize=(10,5))
plt.plot(kl1 / np.max(kl1), label='KL-divergence')
plt.plot(kli1 / np.max(kli1), label='Reverse KL-divergence')
plt.plot(was1 / np.max(was1), label='EMD')
plt.plot(mse1 / np.max(mse1), label='MSE')
plt.legend()
plt.show()

['13labels_testMAE2-checkpoint-52-stanford_gates2.pth', '13labels_testMAE2-checkpoint-51-stanford_coupa0.pth', '13labels_testMAE2-checkpoint-56-stanford_little3.pth', '13labels_testMAE2-checkpoint-40-stanford_bookstore4.pth', '13labels_testMAE2-checkpoint-56-stanford_coupa2.pth', '13labels_testMAE2-checkpoint-21-stanford_hyang10.pth', '13labels_testMAE2-checkpoint-59-stanford_hyang2.pth', '13labels_testMAE2-checkpoint-71-stanford_bookstore0.pth', '13labels_testMAE2-checkpoint-58-stanford_coupa1.pth', '13labels_testMAE2-checkpoint-58-stanford_coupa3.pth', '13labels_testMAE2-checkpoint-33-stanford_gates1.pth', '13labels_testMAE2-checkpoint-61-stanford_gates3.pth', '13labels_testMAE2-checkpoint-46-stanford_deathCircle0.pth']
stanford_gates2
Resume checkpoint /data/placido/13labels_testMAE2-checkpoint-52-stanford_gates2.pth
With optim & sched!

Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).

KL-divergence: 0.8419504165649414
Reverse KL-divergence: 6.667407512664795
EMD: 107.67
MSE: 5.05e-09
stanford_coupa0
Resume checkpoint /data/placido/13labels_testMAE2-checkpoint-51-stanford_coupa0.pth

Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).

With optim & sched!

KL-divergence: 0.1692814975976944
Reverse KL-divergence: 0.7065452933311462
EMD: 19.52
MSE: 1.79e-09
stanford_little3
Resume checkpoint /data/placido/13labels_testMAE2-checkpoint-56-stanford_little3.pth

Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).

With optim & sched!

KL-divergence: 0.34849080443382263
Reverse KL-divergence: 1.8394603729248047
EMD: 133.34
MSE: 2.00e-10
stanford_bookstore4
Resume checkpoint /data/placido/13labels_testMAE2-checkpoint-40-stanford_bookstore4.pth
With optim & sched!

libpng warning: iCCP: known incorrect sRGB profile

TRAINED MODELS¶

Variables definition¶

Loading of the models¶

Testing closed corridors (completely or partially closed)¶

Model 1 testing¶